Grokking Tree Coding Patterns for Interviews
Rate this course
Ask Author
Contribute
Back to course home

0% completed

Vote For New Content
Introduction
Course Overview
Basics of Tree
Introduction to Tree
Types of Tree
BST Traversal Techniques
BST Operations
Level Order Traversal Pattern (easy)
Introduction to Level Order Traversal Pattern
Reverse Level Order Traversal (easy)
Solution: Reverse Level Order Traversal
Find Largest Value in Each Tree Row (medium)
Solution: Find Largest Value in Each Tree Row
Maximum Width of Binary Tree (medium)
Solution: Maximum Width of Binary Tree
Maximum Level Sum of a Binary Tree (medium)
Solution: Maximum Level Sum of a Binary Tree
Zigzag Traversal (medium)
Solution: Zigzag Traversal
Even Odd Tree (medium)
Solution: Even Odd Tree
N-ary Tree Level Order Traversal (hard)
Solution: N-ary Tree Level Order Traversal
Tree Depth Pattern (easy)
Introduction to Tree Depth Pattern
Maximum Depth (or Height) of Binary Tree (easy)
Solution: Maximum Depth (or Height) of Binary Tree
Minimum Depth of a Binary Tree (easy)
Solution: Minimum Depth of a Binary Tree
Balanced Binary Tree (easy)
Solution: Balanced Binary Tree
Tree Diameter (easy)
Solution: Tree Diameter
Maximum Depth of N-ary Tree (easy)
Solution: Maximum Depth of N-ary Tree
Find maximum depth of subtree (medium)
Solution: Find maximum depth of subtree
Introduction to Root to Leaf Path Pattern
Binary Tree Paths (easy)
Solution: Binary Tree Paths
Sum of Root To Leaf Binary Numbers (easy)
Solution: Sum of Root To Leaf Binary Numbers
Insufficient Nodes in Root to Leaf Paths (medium)
Solution: Insufficient Nodes in Root to Leaf Paths
Smallest String Starting From Leaf (medium)
Solution: Smallest String Starting From Leaf
Pseudo-Palindromic Paths in a Binary Tree (medium)
Solution: Pseudo-Palindromic Paths in a Binary Tree
All Paths for a Sum (medium)
Solution: All Paths for a Sum
Sum of Path Numbers (medium)
Solution: Sum of Path Numbers
Path With Given Sequence (medium)
Solution: Path With Given Sequence
Count Paths for a Sum (medium)
Solution: Count Paths for a Sum
Introduction to Leaf Processing Pattern
Sum of Left Leaves (easy)
Solution: Sum of Left Leaves
Leaf-Similar Trees (easy)
Solution: Leaf-Similar Trees
Check if all leaves are at same level (medium)
Solution: Check if all leaves are at same level
Delete Leaves With a Given Value (medium)
Solution: Delete Leaves With a Given Value
Deepest Leaves Sum (medium)
Solution: Deepest Leaves Sum
Introduction to Tree View Pattern
Right View of a Binary Tree (medium)
Solution: Right View of a Binary Tree
Top View Of the Binary Tree (medium)
Solution: Top View Of the Binary Tree
Bottom View Of the Binary Tree (medium)
Solution: Bottom View Of the Binary Tree
Boundary of Binary Tree (medium)
Solution: Boundary of Binary Tree
Introduction to Comparison of Two Trees Pattern
Symmetric Tree (easy)
Solution: Symmetric Tree
Mirror Image Trees (medium)
Solution: Mirror Image Trees
Subtree of Another Tree (easy)
Solution: Subtree of Another Tree
Isomorphic Trees (medium)
Solution: Isomorphic Trees
Introduction to Serialize and Deserialize Tree Pattern
Serialize and Deserialize BST (medium)
Solution: Serialize and Deserialize BST
Verify Preorder Serialization of a Binary Tree (medium)
Solution: Verify Preorder Serialization of a Binary Tree
Create Binary Tree From Descriptions (medium)
Solution: Create Binary Tree From Descriptions
Serialize and Deserialize N-ary Tree (hard)
Solution: Serialize and Deserialize N-ary Tree
Solution: Connect All Level Order Siblings

Problem Statement

Given a root of the binary tree, connect each node with its level order successor. The last node of each level should point to the first node of the next level.

Examples

Example 1

  • Input: root = [1, 2, 3, 4, 5, 6, 7]
Image
  • Output: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> null
  • Explanation: The tree is traversed level by level using BFS. Each node is connected to its next node in level order traversal, including connections between levels. The last node (7) points to null.

Example 2

  • Input: root = [12, 7, 1, 9, null, 10, 5]
Image
  • Output: 12 -> 7 -> 1 -> 9 -> 10 -> 5 -> null
  • Explanation: Each node is connected to its next node in level order traversal. The last node (5) points to null, completing the connection of all level order siblings.

Constraints:

  • The number of nodes in the tree is in the range [0, 212 - 1].
  • -1000 <= Node.val <= 1000

Solution

In the previous problem, we connected nodes within the same level. Here, we extend the connection across levels, linking every node to its next node in level order traversal. Using BFS, we process nodes one by one, maintaining a previousNode to link the dequeued node. The last node in traversal points to null, forming a single linked list that follows the tree’s level order sequence.

Step-by-Step Algorithm

  1. Handle the Base Case:

    • If the tree is empty (root == null), return null.
  2. Initialize BFS Traversal:

    • Create a queue and enqueue the root node to start the level order traversal.
    • Define previousNode = null to track the last processed node and establish connections.
    • Define currentNode to hold the node dequeued at each step.
  3. Process Nodes One by One:

    • While the queue is not empty:
      • Dequeue the front node and store it in currentNode.
      • If previousNode is not null, connect previousNode.next = currentNode to maintain level order linking.
      • Update previousNode = currentNode to track the last processed node.
  4. Enqueue the Children of the Current Node:

    • If currentNode.left exists, enqueue it.
    • If currentNode.right exists, enqueue it.
  5. Continue Until All Nodes Are Processed.

    • The last node in traversal will automatically point to null, marking the end of the sequence.
  6. Return the Root Node After All Connections Are Established.

Algorithm Walkthrough

Image
  1. Initialize BFS Traversal:

    • Start with the root node 12.
    • Initialize an empty queue and enqueue 12.
    • Initialize previousNode = null.

    Queue: [12]

  2. Process Node 12:

    • Dequeue 12:
      • Since previousNode is null, assign previousNode = 12.
      • Enqueue left child 7.
      • Enqueue right child 1.

    Queue after processing: [7, 1]
    Next Pointer Connection: 12 -> null

  3. Process Node 7:

    • Dequeue 7:
      • Connect 12.next = 7 (link 12 to 7).
      • Update previousNode = 7.
      • Enqueue left child 9 (no right child).

    Queue after processing: [1, 9]
    Next Pointer Connections: 12 -> 7 -> null

  4. Process Node 1:

    • Dequeue 1:
      • Connect 7.next = 1 (link 7 to 1).
      • Update previousNode = 1.
      • Enqueue left child 10.
      • Enqueue right child 5.

    Queue after processing: [9, 10, 5]
    Next Pointer Connections: 12 -> 7 -> 1 -> null

  5. Process Node 9:

    • Dequeue 9:
      • Connect 1.next = 9 (link 1 to 9).
      • Update previousNode = 9.
      • 9 has no children.

    Queue after processing: [10, 5]
    Next Pointer Connections: 12 -> 7 -> 1 -> 9 -> null

  6. Process Node 10:

    • Dequeue 10:
      • Connect 9.next = 10 (link 9 to 10).
      • Update previousNode = 10.
      • 10 has no children.

    Queue after processing: [5]
    Next Pointer Connections: 12 -> 7 -> 1 -> 9 -> 10 -> null

  7. Process Node 5:

    • Dequeue 5:
      • Connect 10.next = 5 (link 10 to 5).
      • Update previousNode = 5.
      • 5 has no children.

    Queue after processing: []
    Next Pointer Connections: 12 -> 7 -> 1 -> 9 -> 10 -> 5 -> null

Final Connected Tree Representation

12 -> 7 -> 1 -> 9 -> 10 -> 5 -> null

Code

Here is the code for this algorithm:

Java

. . . .

Complexity Analysis

Time Complexity

The time complexity of the above algorithm is , where ‘N’ is the total number of nodes in the tree. This is due to the fact that we traverse each node once.

Space Complexity

The space complexity of the above algorithm will be which is required for the queue. Since we can have a maximum of N/2 nodes at any level (this could happen only at the lowest level), therefore we will need space to store them in the queue.

Connect All Level Order Siblings (medium)
Introduction to Tree Depth First Search Pattern
Mark as Completed

On this page

Problem Statement

Examples

Solution

Step-by-Step Algorithm

Algorithm Walkthrough

Code

Complexity Analysis

Time Complexity

Space Complexity